function goPage(url, params = null) {
  if (params) {
    url = url + "?" + toUrlParams(params);
  }
  uni.navigateTo({
    url: url,
  });
}

function validatePhoneNumber(phoneNumber) {
  // 支持手机号码和座机号码
  // 手机号码：11位，以1开头
  // 座机号码：区号（3-4位）-电话号码（7-8位），区号和电话号码之间可以有横杠，也可以没有
  const regex = /^1[3-9]\d{9}$|^(\d{3,4}-?)?\d{7,8}$/;
  return regex.test(phoneNumber);
}

function toNormalArr(data) {
  return JSON.parse(JSON.stringify(data));
}

function toUrlParams(params) {
  let arr = [];
  for (let key in params) {
    arr.push(key + "=" + params[key]);
  }
  return arr.join("=");
}

function getInt(s) {
  return parseInt(s);
}

function getParams(data, fieldStr) {
  let params = {};
  let fields = fieldStr.split(",");
  for (const index in fields) {
    params[index] = data[index];
  }
  return params;
}

function setField(items, field, value) {
  let params = [];
  params[field] = value;
  return items.map((item) => {
    return Object.assign(item, params);
  });
}

function removeField(items, field, value) {}

function getOptionsItems(items, valueField = "id", labelField = "name") {
  let arr = [];
  for (let i = 0; i < items.length; i++) {
    arr.push({ value: items[i][valueField], label: items[i][labelField] });
  }
  return arr;
}

//设置active
function setItemActive(
  items,
  item,
  fieldName = "id",
  className = "active",
  trueValue = true,
  falseValue = false
) {
  for (let i = 0; i < items.length; i++) {
    items[i][className] = falseValue;
  }
  item[className] = trueValue;
}
function numFilter(value) {
  return Number(value).toFixed(2); //截取当前数据到小数点后两位
}
function getLabelFromOptions(options, value) {
  let label = "";
  for (let i = 0; i < options.length; i++) {
    if (options[i].value == value) {
      label = options[i].label;
      break;
    }
  }
  return label;
}
function animate(obj, css, interval, speedFactor, func) {
  clearInterval(obj.timer);
  function getStyle(obj, prop) {
    if (obj.currentStyle) return obj.currentStyle[prop]; // ie
    else return document.defaultView.getComputedStyle(obj, null)[prop]; // 非ie
  }
  obj.timer = setInterval(function () {
    var flag = true;
    for (var prop in css) {
      var cur = 0;
      if (prop == "opacity")
        cur = Math.round(parseFloat(getStyle(obj, prop)) * 100);
      else cur = parseInt(getStyle(obj, prop));
      var speed = (css[prop] - cur) * speedFactor;
      speed = speed > 0 ? Math.ceil(speed) : Math.floor(speed);
      if (cur != css[prop]) flag = false;
      if (prop == "opacity") {
        obj.style.filter = "alpha(opacity : '+(cur + speed)+' )";
        obj.style.opacity = (cur + speed) / 100;
      } else obj.style[prop] = cur + speed + "px";
    }
    if (flag) {
      clearInterval(obj.timer);
      if (func) func();
    }
  }, interval);
}

function validRequired(rule, value, callback) {
  if (value === "") {
    callback(new Error("Please enter your password"));
  } else {
    if (this.formCustom.passwdCheck !== "") {
      // 对第二个密码框单独验证
      this.$refs.formCustom.validateField("passwdCheck");
    }
    callback();
  }
}

function changeItemsKey(items, keys) {
  var data = [];
  for (var i = 0; i < items.length; i++) {
    var newItem = {};
    for (var key in keys) {
      if (typeof items[i][key] != undefined) {
        newItem[keys[key]] = items[i][key];
      }
    }
    if (items[i].display == 1) {
      data.push(newItem);
    }
  }
  return data;
}

function timeToDate(timestamp) {
  var re = /^[0-9]+$/;
  if (!re.test(timestamp)) {
    return timestamp;
  }
  var date = new Date(timestamp * 1000); //时间戳为10位需*1000，时间戳为13位的话不需乘1000
  var Y = date.getFullYear() + "-";
  var M =
    (date.getMonth() + 1 < 10
      ? "0" + (date.getMonth() + 1)
      : date.getMonth() + 1) + "-";
  var D =
    date.getDate() < 10 ? "0" + date.getDate() + " " : date.getDate() + " ";
  var h =
    (date.getHours() < 10 ? "0" + date.getHours() : date.getHours()) + ":";
  var m =
    (date.getMinutes() < 10 ? "0" + date.getMinutes() : date.getMinutes()) +
    ":";
  var s = date.getSeconds() < 10 ? "0" + date.getSeconds() : date.getSeconds();
  return Y + M + D + h + m + s;
}
function getWeekDate(timestamp) {
  let now = new Date(timestamp * 1000);
  let day = now.getDay();
  let weeks = new Array(
    "星期日",
    "星期一",
    "星期二",
    "星期三",
    "星期四",
    "星期五",
    "星期六"
  );
  let week = weeks[day];
  return week;
}

function isEmptyObject(obj) {
  return JSON.stringify(obj) === "{}" ? true : false;
}

function dateFormat(date, fmt) {
  if (!date) {
    return "";
  }
  if (typeof date == "number" || typeof date == "string") {
    var date = new Date(date * 1000);
  }
  var o = {
    "M+": date.getMonth() + 1, //月份
    "d+": date.getDate(), //日
    "h+": date.getHours(), //小时
    "m+": date.getMinutes() < 10 ? "0" + date.getMinutes() : date.getMinutes(), //分
    "s+": date.getSeconds() < 10 ? "0" + date.getSeconds() : date.getSeconds(), //秒
    "q+": Math.floor((date.getMonth() + 3) / 3), //季度
    S: date.getMilliseconds(), //毫秒
  };
  if (/(y+)/.test(fmt))
    fmt = fmt.replace(
      RegExp.$1,
      (date.getFullYear() + "").substr(4 - RegExp.$1.length)
    );
  for (var k in o)
    if (new RegExp("(" + k + ")").test(fmt))
      fmt = fmt.replace(
        RegExp.$1,
        RegExp.$1.length == 1 ? o[k] : ("00" + o[k]).substr(("" + o[k]).length)
      );
  return fmt;
}

function inArray(search, array) {
  for (var i in array) {
    if (array[i] == search) {
      return true;
    }
  }
  return false;
}

function isUserLogin() {
  let token = global.isLogin();
  return token ? token : false;
}

function sleep(delay) {
  var start = new Date().getTime();
  while (new Date().getTime() - start < delay) {
    continue;
  }
}

function timeago(dateTimeStamp) {
  //dateTimeStamp是一个时间毫秒，注意时间戳是秒的形式，在这个毫秒的基础上除以1000，就是十位数的时间戳。13位数的都是时间毫秒。
  dateTimeStamp = dateTimeStamp * 1000;
  let minute = 1000 * 60; //把分，时，天，周，半个月，一个月用毫秒表示
  let hour = minute * 60;
  let day = hour * 24;
  let week = day * 7;
  let halfamonth = day * 15;
  let month = day * 30;
  let now = new Date().getTime(); //获取当前时间毫秒

  let diffValue = now - dateTimeStamp; //时间差

  if (diffValue < 0) {
    return;
  }
  let minC = diffValue / minute; //计算时间差的分，时，天，周，月
  let hourC = diffValue / hour;
  let dayC = diffValue / day;
  let weekC = diffValue / week;
  let monthC = diffValue / month;
  let result = "";
  if (monthC >= 1 && monthC <= 3) {
    result = " " + parseInt(monthC) + "月前";
  } else if (weekC >= 1 && weekC <= 3) {
    result = " " + parseInt(weekC) + "周前";
  } else if (dayC >= 1 && dayC <= 6) {
    result = " " + parseInt(dayC) + "天前";
  } else if (hourC >= 1 && hourC <= 23) {
    result = " " + parseInt(hourC) + "小时前";
  } else if (minC >= 1 && minC <= 59) {
    result = " " + parseInt(minC) + "分钟前";
  } else if (diffValue >= 0 && diffValue <= minute) {
    result = "刚刚";
  } else {
    let datetime = new Date();
    datetime.setTime(dateTimeStamp);
    let Nyear = datetime.getFullYear();
    let Nmonth =
      datetime.getMonth() + 1 < 10
        ? "0" + (datetime.getMonth() + 1)
        : datetime.getMonth() + 1;
    let Ndate =
      datetime.getDate() < 10 ? "0" + datetime.getDate() : datetime.getDate();
    let Nhour =
      datetime.getHours() < 10
        ? "0" + datetime.getHours()
        : datetime.getHours();
    let Nminute =
      datetime.getMinutes() < 10
        ? "0" + datetime.getMinutes()
        : datetime.getMinutes();
    let Nsecond =
      datetime.getSeconds() < 10
        ? "0" + datetime.getSeconds()
        : datetime.getSeconds();
    result = Nyear + "-" + Nmonth + "-" + Ndate;

    //result = timeToDate(dateTimeStamp/1000)
  }
  return result;
}

// 月-日 时:分
function compareDatesMMDDHHmm(dateStr1, dateStr2) {
  // 辅助函数，用于将自定义日期字符串转换为标准的日期时间字符串
  function convertToStandardDate(dateStr) {
    // 解析年月日
    let parts = dateStr.match(/(\d+月)(\d+日) (\d+:\d+)/);
    if (!parts) return null; // 如果字符串格式不正确，返回 null

    let year = new Date().getFullYear(); // 假设日期为当前年份
    let month = parseInt(parts[1].slice(0, -1), 10) - 1; // 月份需要减1
    let day = parseInt(parts[2].slice(0, -1), 10);
    let time = parts[3];

    // 构建标准的日期时间字符串
    let standardDateStr = `${year}-${month < 10 ? '0' + month : month}-${day < 10 ? '0' + day : day}T${time}:00`;

    // 转换为 Date 对象
    return new Date(standardDateStr);
  }

  // 转换并比较两个日期
  let date1 = convertToStandardDate(dateStr1);
  let date2 = convertToStandardDate(dateStr2);

  if (date1 === null || date2 === null) {
    throw new Error('Invalid date format'); // 如果日期格式不正确，抛出错误
  }

  // 比较两个日期
  if (date1 > date2) {
    return 1; // date1 更大
  } else if (date1 < date2) {
    return -1; // date2 更大
  } else {
    return 0; // 两个日期相等
  }
}

function compareTime(time1, time2) {
  // 将字符串解析为Date对象
  const parts1 = time1.split(' ');
  const datePart1 = parts1[0].split('-');
  const timePart1 = parts1[1].split(':');
  const date1 = new Date(datePart1[0], parseInt(datePart1[1], 10) - 1, datePart1[2],
      timePart1[0], timePart1[1]);

  const parts2 = time2.split(' ');
  const datePart2 = parts2[0].split('-');
  const timePart2 = parts2[1].split(':');
  const date2 = new Date(datePart2[0], parseInt(datePart2[1], 10) - 1, datePart2[2],
      timePart2[0], timePart2[1]);

  if (date1 > date2) {
    return 1;
  } else if (date1 < date2) {
    return -1;
  } else {
    return 0;
  }
}

function formatDate(date) {
  const year = date.getFullYear();
  const month = String(date.getMonth() + 1).padStart(2, '0'); // 月份从0开始，所以需要+1，并用0填充
  const day = String(date.getDate()).padStart(2, '0'); // 用0填充
  const hours = String(date.getHours()).padStart(2, '0'); // 用0填充
  const minutes = String(date.getMinutes()).padStart(2, '0'); // 用0填充

  return `${year}-${month}-${day} ${hours}:${minutes}`;
}

function replaceDatePart(originalDateString, newDateString) {
  // 尝试解析原始日期字符串
  const originalDate = new Date(originalDateString.replace(/-/g, '/'));
  if (isNaN(originalDate.getTime())) {
    throw new Error('Invalid original date string');
  }
  // 尝试解析新的年月日字符串
  const parts = newDateString.split('-').map(Number);
  if (parts.length !== 3 || isNaN(parts[0]) || isNaN(parts[1]) || isNaN(parts[2])) {
    throw new Error('Invalid new date string');
  }
  // 设置新的年月日
  originalDate.setFullYear(parts[0]);
  originalDate.setMonth(parts[1] - 1); // 注意月份是从 0 开始的
  originalDate.setDate(parts[2]);
  // 格式化新的日期字符串，保持时分秒不变
  const hours = originalDate.getHours().toString().padStart(2, '0');
  const minutes = originalDate.getMinutes().toString().padStart(2, '0');

  // 返回新的日期字符串
  return `${originalDate.getFullYear()}-${('0' + (originalDate.getMonth() + 1)).slice(-2)}-${('0' + originalDate.getDate()).slice(-2)} ${hours}:${minutes}`;
}
function addHoursToCurrentTime(dateTimeString, hoursToAdd) {
  // 验证输入
  if (typeof dateTimeString !== 'string' || !/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$/.test(dateTimeString)) {
    throw new Error('Invalid date time format. Expected format: yyyy-MM-dd HH:mm');
  }
  if (typeof hoursToAdd !== 'number' || isNaN(hoursToAdd) || !isFinite(hoursToAdd)) {
    throw new Error('Invalid hours to add. Expected a finite number.');
  }

  // 将字符串解析为Date对象
  const parts = dateTimeString.split(' ');
  const datePart = parts[0].split('-');
  const timePart = parts[1].split(':');

  const date = new Date(datePart[0], parseInt(datePart[1], 10) - 1, datePart[2], timePart[0], timePart[1]);

  // 添加小时数
  date.setHours(date.getHours() + hoursToAdd);

  // 转换回字符串格式
  const year = date.getFullYear();
  const month = String(date.getMonth() + 1).padStart(2, '0');
  const day = String(date.getDate()).padStart(2, '0');
  const hours = String(date.getHours()).padStart(2, '0');
  const minutes = String(date.getMinutes()).padStart(2, '0');

  return `${year}-${month}-${day} ${hours}:${minutes}`;
}

function addHoursToCurrentTime0(startDateStr, hoursToAdd) {
  const startTime = new Date(startDateStr);
  // 检查转换是否成功
  if (isNaN(startTime.getTime())) {
    console.error('无效的起始时间:', startDateStr);
    return null;
  }
  // 给起始时间加上小时数
  const newHours = startTime.getHours() + hoursToAdd;
  // 设置小时数
  startTime.setHours(newHours);
  // 格式化时间字符串（可选，根据你的需求调整格式）
  return formatDate(startTime);
}

function addDay(dateStr, nDay) {
  // 检查输入字符串的格式
  const regex = /^\d{4}-\d{2}-\d{2}$/;
  if (!regex.test(dateStr)) {
    throw new Error('Invalid date format. Please use "yyyy-MM-dd".');
  }
  // 将字符串转换为Date对象
  const parts = dateStr.split('-');
  const date = new Date(parts[0], parseInt(parts[1]) - 1, parseInt(parts[2])); // 注意月份是从0开始的
  // 增加n天
  date.setDate(date.getDate() + nDay);
  // 格式化新的日期为字符串
  const year = String(date.getFullYear()).padStart(4, '0');
  const month = String(date.getMonth() + 1).padStart(2, '0'); // 月份加1，并转换为两位数字
  const day = String(date.getDate()).padStart(2, '0');
  return `${year}-${month}-${day}`;
}

// 找到满足连续n个小时的起始小时
function findConsecutiveHoursStartIndex(array1, array2, startHour, n) {
  // 验证输入
  if (n <= 0 || startHour < 0 || startHour >= 24 || !Array.isArray(array1) || !Array.isArray(array2) || array1.length !== 24 || array2.length !== 24) {
    throw new Error('Invalid input');
  }
  let currentIndex = startHour; // 当前索引从起始小时开始
  let consecutiveCount = 0; // 跟踪连续的checked为false的小时数
  let foundStartHour = null; // 用于记录找到的第一个小时的索引
  // 合并两个数组，以便连续查找
  const combinedArrays = [...array1, ...array2];
  // 遍历合并后的数组
  for (let i = 0; i < combinedArrays.length && consecutiveCount < n; i++) {
    // 如果当前小时未被设置过，则开始计数
    if (!combinedArrays[i].checked) {
      consecutiveCount++;
      // 如果是开始计数的第一个小时，则记录索引
      if (consecutiveCount === 1) {
        foundStartHour = (i < 24) ? i : i - 24; // 转换为原始数组的索引
      }

      if (consecutiveCount === n) {
        return foundStartHour; // 返回起始时刻的索引
      }
    } else {
      // 如果当前小时已经被设置过，则重置连续小时计数器
      consecutiveCount = 0;
      foundStartHour = null;
    }
  }
  // 如果没有找到足够的连续小时
  return null; // 返回null表示未找到
}

function setConsecutiveHoursChecked(array1, array2, startHour, n) {
  // 验证输入
  if (n <= 0 || startHour < 0 || startHour >= 24 || !Array.isArray(array1) || !Array.isArray(array2) || array1.length !== 24 || array2.length !== 24) {
    console.log('输入无效')
    return false; // 输入无效，返回false
  }
  //重置
  for (let i = 0; i < array1.length; i++) {
    if (array1[i].checked === 2) {
      array1[i].checked = 0; // 设置checked为0
    }
  }
  //重置
  for (let i = 0; i < array2.length; i++) {
    if (array2[i].checked === 2) {
      array2[i].checked = 0; // 设置checked为0
    }
  }

  let currentIndex = startHour; // 当前索引从起始小时开始
  let consecutiveCount = 0; // 跟踪连续的checked为false的小时数
  let totalHoursSet = 0; // 跟踪总共设置了checked为true的小时数
  let changedIndices = []; // 跟踪自己刚刚设置了checked为true的索引
  // 遍历第一个数组
  for (let i = startHour; i < array1.length && totalHoursSet < n; i++) {
    // 如果当前索引等于起始小时或者当前小时未被设置过
    if (i === currentIndex || array1[i].checked!==2) {
      array1[i].checked = 2; // 设置checked为true
      consecutiveCount++; // 连续小时数加1
      totalHoursSet++; // 总共设置了的小时数加1
      changedIndices.push(i)
      // 如果找到了n个连续的小时，则退出循环
      if (consecutiveCount === n) {
        break;
      }
      // 如果当前小时不是起始小时，则递增当前索引
      if (i !== currentIndex) {
        currentIndex++;
      }
      // 如果当前索引超过第一个数组的长度，则进入第二个数组
      if (currentIndex >= array1.length) {
        break;
      }
    } else {
      // 如果当前小时已经被设置过，则重置连续小时计数器
      consecutiveCount = 0;
    }
  }
  // 如果第一个数组中没有找到足够的连续小时，继续在第二个数组中查找
  currentIndex -= array1.length; // 调整索引到第二个数组的起始位置
  for (let i = 0; i < array2.length && totalHoursSet < n; i++) {
    // 如果当前小时未被设置过
    if (array2[i].checked!==2) {
      array2[i].checked = 2; // 设置checked为true
      consecutiveCount++; // 连续小时数加1
      totalHoursSet++; // 总共设置了的小时数加1
      changedIndices.push(i+array1.length)
      // 如果找到了n个连续的小时，则退出循环
      if (consecutiveCount === n) {
        break;
      }
      // 递增当前索引
      currentIndex++;
    } else {
      // 如果当前小时已经被设置过，则重置连续小时计数器
      consecutiveCount = 0;
    }
  }

// 如果没有找到足够的连续小时
    if (totalHoursSet < n) {
      // 仅重置自己刚刚设置的checked字段
      for (let index of changedIndices) {
        if (index < array1.length) {
          array1[index].checked = 0;
        } else {
          array2[index - array1.length].checked = 0;
        }
      }
      console.log('没有找到足够的连续小时来设置checked字段。');
      return false; // 返回false表示失败
    }
  return true; // 返回true表示成功
}
function setConsecutiveHours(array1, startHour, n) {
  // 验证输入
  if (n <= 0 || startHour < 0 || !Array.isArray(array1)) {
    console.log('输入无效')
    return false; // 输入无效，返回false
  }
  //重置
  for (let i = 0; i < array1.length; i++) {
    if (array1[i].disabled === 2) {
      array1[i].disabled = 0; // 设置checked为0
    }
  }

  let currentIndex = startHour; // 当前索引从起始小时开始
  let consecutiveCount = 0; // 跟踪连续的checked为false的小时数
  let totalHoursSet = 0; // 跟踪总共设置了checked为true的小时数
  let changedIndices = []; // 跟踪自己刚刚设置了checked为true的索引
  // 遍历第一个数组
  for (let i = startHour; i < array1.length && totalHoursSet < n; i++) {
    // 如果当前索引等于起始小时或者当前小时未被设置过
    if (i === currentIndex || array1[i].disabled===0) {
      array1[i].disabled = 2; // 设置checked为true
      consecutiveCount++; // 连续小时数加1
      totalHoursSet++; // 总共设置了的小时数加1
      changedIndices.push(i)
      // 如果找到了n个连续的小时，则退出循环
      if (consecutiveCount === n) {
        break;
      }
      // 如果当前小时不是起始小时，则递增当前索引
      if (i !== currentIndex) {
        currentIndex++;
      }
      // 如果当前索引超过第一个数组的长度，则进入第二个数组
      if (currentIndex >= array1.length) {
        break;
      }
    } else {
      // 如果当前小时已经被设置过，则重置连续小时计数器
      consecutiveCount = 0;
    }
  }
// 如果没有找到足够的连续小时
    if (totalHoursSet < n) {
      // 仅重置自己刚刚设置的checked字段
      for (let index of changedIndices) {
        if (index < array1.length) {
          array1[index].disabled = 0;
        }
      }
      console.log('没有找到足够的连续小时来设置checked字段。');
      return false; // 返回false表示失败
    }
  return true; // 返回true表示成功
}

function setConsecutiveArrays(arr, startIndex, n) {
  console.log('设置起始：', startIndex, n)
  if (startIndex < 0 || startIndex >= arr.length || n <= 0 || startIndex + n > arr.length) {
    // 起始下标或n不合法
    return;
  }
  //重置
  for (let i = 0; i < arr.length; i++) {
    if (arr[i].disabled === 2) {
      arr[i].disabled = 0; // 设置checked为0
    }
  }
  let currentLength = 0; // 当前连续0的个数
  let startSetIndex = -1; // 设置checked为2的起始下标
  // 遍历数组，从startIndex开始
  for (let i = startIndex; i < arr.length && currentLength < n; i++) {
    // 如果当前元素的checked为0，并且前面没有遇到checked为1或2的元素
    if (arr[i].disabled === 0 && (startSetIndex === -1 || arr[i - 1].disabled === 0)) {
      currentLength++; // 连续0的个数加1
      // 如果当前是连续序列的开始
      if (startSetIndex === -1) {
        startSetIndex = i; // 记录起始下标
      }
      // 如果已经找到了n个连续的0，则退出循环
      if (currentLength === n) {
        break;
      }
    } else if (arr[i].disabled !== 0) {
      // 如果遇到了checked为1或2的元素，重置计数器
      currentLength = 0;
      startSetIndex = -1;
    }
  }
  // 如果找到了连续的n个0，则设置它们的checked为2
  if (startSetIndex !== -1) {
    for (let i = startSetIndex; i < startSetIndex + n; i++) {
      arr[i].disabled = 2;
    }
  }
  // 返回标记的数组下标（如果需要的话）
  return startSetIndex;
}

function findConsecutiveArrayIndex(arr, startIndex, n) {
  if (startIndex < 0 || startIndex >= arr.length || n <= 0 || startIndex + n > arr.length) {
    // 起始下标或n不合法
    return;
  }
  let currentLength = 0; // 当前连续0的个数
  let startSetIndex = -1; // 设置disabled为2的起始下标
  // 遍历数组，从startIndex开始
  for (let i = startIndex; i < arr.length && currentLength < n; i++) {
    // 如果当前元素的disabled不等于1，并且前面没有遇到disabled为1或2的元素
    if (arr[i].disabled !== 1 && (startSetIndex === -1 || arr[i - 1].disabled !== 1)) {
      currentLength++; // 连续0的个数加1
      // 如果当前是连续序列的开始
      if (startSetIndex === -1) {
        startSetIndex = i; // 记录起始下标
      }
      // 如果已经找到了n个连续的0，则退出循环
      if (currentLength === n) {
        break;
      }
    } else if (arr[i].disabled !== 0) {
      // 如果遇到了checked为1或2的元素，重置计数器
      currentLength = 0;
      startSetIndex = -1;
    }
  }
  return startSetIndex;
}

function findConsecutiveHoursIndex(array1, startHour, n) {
  // 验证输入
  if (n <= 0 || startHour < 0 || !Array.isArray(array1)) {
    console.log('输入无效')
    return false; // 输入无效，返回false
  }

  let currentIndex = startHour; // 当前索引从起始小时开始
  let consecutiveCount = 0; // 跟踪连续的checked为false的小时数
  let totalHoursSet = 0; // 跟踪总共设置了checked为true的小时数
  let changedIndices = []; // 跟踪自己刚刚设置了checked为true的索引
  // 遍历第一个数组
  for (let i = startHour; i < array1.length && totalHoursSet < n; i++) {
    // 如果当前索引等于起始小时或者当前小时未被设置过
    if (i === currentIndex || array1[i].disabled!==2) {
      consecutiveCount++; // 连续小时数加1
      totalHoursSet++; // 总共设置了的小时数加1
      changedIndices.push(i)
      // 如果找到了n个连续的小时，则退出循环
      if (consecutiveCount === n) {
        break;
      }
      // 如果当前小时不是起始小时，则递增当前索引
      if (i !== currentIndex) {
        currentIndex++;
      }
      // 如果当前索引超过第一个数组的长度，则进入第二个数组
      if (currentIndex >= array1.length) {
        break;
      }
    } else {
      // 如果当前小时已经被设置过，则重置连续小时计数器
      consecutiveCount = 0;
    }
  }
// 如果没有找到足够的连续小时
  if (totalHoursSet < n) {
    console.log('没有找到足够的连续小时来设置checked字段。');
    return null; //
  }
  return currentIndex; // 返回起始
}


function handlePrice(val) {
  //金额转换 分->元 保留2位小数 并每隔3位用逗号分开 1,234.56
  var str = val.toFixed(2) + "";
  var intSum = str
    .substring(0, str.indexOf("."))
    .replace(/\B(?=(?:\d{3})+$)/g, ","); //取到整数部分
  var dot = str.substring(str.length, str.indexOf(".")); //取到小数部分搜索
  var ret = intSum + dot;
  return ret;
}

function getDistance(lat1, lng1, lat2, lng2) {
  var radLat1 = (lat1 * Math.PI) / 180.0;
  var radLat2 = (lat2 * Math.PI) / 180.0;
  var a = radLat1 - radLat2;
  var b = (lng1 * Math.PI) / 180.0 - (lng2 * Math.PI) / 180.0;
  var s =
    2 *
    Math.asin(
      Math.sqrt(
        Math.pow(Math.sin(a / 2), 2) +
          Math.cos(radLat1) * Math.cos(radLat2) * Math.pow(Math.sin(b / 2), 2)
      )
    );
  s = s * 6378.137; // EARTH_RADIUS;
  s = Math.round(s * 10000) / 10000;
  return s;
}

/**
 * 返回当前日期的第x天后的未来时间
 * @param {Number} days 返回未来x天
 * @returns {Array}
 */
const getFetureDay = (days = 7) => {
  // 获取当前日期
  const date = new Date();
  // 获取当前星期几
  const weekByDate = date.getDay();
  // 根据当前星期几计算未来一周的日期
  let futureWeek = [];
  for (let i = 0; i < days; i++) {
    const futureDate = new Date(date.getTime() + i * 24 * 60 * 60 * 1000);
    const futureDay = futureDate.getDate();
    const weekBych = ["周日", "周一", "周二", "周三", "周四", "周五", "周六"];
    const futureWeekday = weekBych[futureDate.getDay()];
    const month =
      futureDate.getMonth() + 1 < 10
        ? "0" + (futureDate.getMonth() + 1)
        : futureDate.getMonth() + 1;
    const day = futureDay < 10 ? "0" + futureDay : futureDay;
    const week =
      weekBych[weekByDate] === futureWeekday ? "今天" : futureWeekday;
    const obj = {
      day,
      month,
      date: `${month}.${day}`,
      week,
    };
    futureWeek.push(obj);
  }
  return futureWeek;
};

/**
 * 返回当前时间的第x小时后的未来时间
 * @param {Number} hour 返回未来x小时
 * @returns {Array}
 */
const getFetureHour = (hour = 2) => {
  // 获取当前时间
  const today = new Date();
  // 将小时数转换为毫秒数
  const millisecondsToAdd = hour * 60 * 60 * 1000;
  // 计算未来时间
  const futureDate = new Date(today.getTime() + millisecondsToAdd);
  return {
    curTime: dateFormat(today, "h:m"),
    fetureTime: dateFormat(futureDate, "h:m"),
  };
};

let configs = {
  getFetureDay,
  getFetureHour,
  handlePrice: handlePrice,
  toNormalArr: toNormalArr,
  getInt: getInt,
  animate: animate,
  getParams: getParams,
  setField: setField,
  setItemActive: setItemActive,
  numFilter: numFilter,
  getOptionsItems: getOptionsItems,
  changeItemsKey: changeItemsKey,
  timeToDate: timeToDate,
  compareTime: compareTime,
  compareDatesMMDDHHmm: compareDatesMMDDHHmm,
  addHoursToCurrentTime: addHoursToCurrentTime,
  addDay: addDay,
  setConsecutiveArrays: setConsecutiveArrays,
  findConsecutiveArrayIndex: findConsecutiveArrayIndex,
  replaceDatePart: replaceDatePart,
  getLabelFromOptions: getLabelFromOptions,
  inArray: inArray,
  isEmptyObject: isEmptyObject,
  validatePhoneNumber: validatePhoneNumber,
  dateFormat: dateFormat,
  isUserLogin: isUserLogin,
  timeago: timeago,
  sleep: sleep,
  goPage: goPage,
  getDistance: getDistance,
  getWeekDate: getWeekDate,
};

export default configs;
